function power_methods_test()
% POWER_METHODS_TEST 幂迭代方法专项测试
% 
% 详细测试各种幂迭代方法的性能和特点

fprintf('=== 幂迭代方法专项测试 ===\n\n');

%% 测试1：收敛速度分析
fprintf('测试1：收敛速度分析\n');
fprintf('目标：分析不同特征值分布对收敛速度的影响\n\n');

% 测试不同的特征值比值
eigenval_ratios = [0.9, 0.7, 0.5, 0.3, 0.1];
fprintf('特征值比值    理论收敛率    实际收敛率    收敛迭代数\n');
fprintf('----------    ----------    ----------    ----------\n');

for ratio = eigenval_ratios
    % 构造具有指定特征值比值的矩阵
    eigenvals = [4, 4*ratio, 4*ratio^2];
    V = orth(randn(3, 3));
    A = V * diag(eigenvals) * V';
    
    % 幂迭代
    x = [1; 1; 1];
    x = x / norm(x);
    errors = [];
    
    for k = 1:50
        y = A * x;
        lambda = x' * y;
        x = y / norm(y);
        
        error = abs(lambda - eigenvals(1));
        errors = [errors; error];
        
        if error < 1e-10
            break;
        end
    end
    
    % 计算收敛率
    if length(errors) > 5
        actual_rate = mean(errors(6:end) ./ errors(5:end-1));
    else
        actual_rate = NaN;
    end
    
    fprintf('%8.1f      %10.3f    %10.3f    %10d\n', ...
            ratio, ratio, actual_rate, length(errors));
end

%% 测试2：初始向量的影响
fprintf('\n测试2：初始向量的影响\n');
fprintf('目标：分析不同初始向量对收敛的影响\n\n');

A2 = [5, 1, 0; 1, 3, 1; 0, 1, 1];
exact_eigenval = max(eig(A2));

% 不同的初始向量
initial_vectors = {
    [1; 0; 0],      % 与第一个特征向量对齐
    [0; 1; 0],      % 与第二个特征向量对齐
    [1; 1; 1],      % 随机向量1
    [1; -1; 1],     % 随机向量2
    [0.001; 1; 1]   % 几乎正交于主特征向量
};

vector_names = {'[1;0;0]', '[0;1;0]', '[1;1;1]', '[1;-1;1]', '[0.001;1;1]'};

fprintf('初始向量      收敛迭代数    最终误差\n');
fprintf('---------     ----------    --------\n');

for i = 1:length(initial_vectors)
    x = initial_vectors{i};
    x = x / norm(x);
    
    for k = 1:100
        y = A2 * x;
        lambda = x' * y;
        x = y / norm(y);
        
        error = abs(lambda - exact_eigenval);
        if error < 1e-10
            break;
        end
    end
    
    fprintf('%-12s  %10d    %.2e\n', vector_names{i}, k, error);
end

%% 测试3：矩阵条件数的影响
fprintf('\n测试3：矩阵条件数的影响\n');
fprintf('目标：分析矩阵条件数对幂迭代稳定性的影响\n\n');

condition_numbers = [1e2, 1e4, 1e6, 1e8, 1e10];
fprintf('条件数        收敛迭代数    数值稳定性\n');
fprintf('--------      ----------    ----------\n');

for cond_num = condition_numbers
    % 构造指定条件数的矩阵
    n = 4;
    eigenvals = [1, 1/sqrt(cond_num), 1/cond_num, 1/(cond_num)];
    V = orth(randn(n, n));
    A3 = V * diag(eigenvals) * V';
    
    % 幂迭代
    x = randn(n, 1);
    x = x / norm(x);
    
    for k = 1:200
        y = A3 * x;
        lambda = x' * y;
        x_new = y / norm(y);
        
        % 检查数值稳定性
        if norm(x_new - x) < 1e-12
            break;
        end
        x = x_new;
    end
    
    final_error = abs(lambda - eigenvals(1));
    stability = final_error < 1e-8;
    
    fprintf('%.0e      %10d    %10s\n', cond_num, k, mat2str(stability));
end

%% 测试4：复特征值的处理
fprintf('\n测试4：复特征值的处理\n');
fprintf('目标：测试幂迭代在复特征值矩阵上的行为\n\n');

% 构造有复特征值的矩阵
theta = pi/6;
A4 = [cos(theta), -sin(theta), 0; sin(theta), cos(theta), 0; 0, 0, 0.5];
fprintf('测试矩阵 A4 (有复特征值):\n');
disp(A4);

eigenvals_complex = eig(A4);
fprintf('特征值: %.4f±%.4fi, %.4f\n', ...
        real(eigenvals_complex(1)), imag(eigenvals_complex(1)), eigenvals_complex(3));

% 幂迭代
x4 = [1; 1; 1];
x4 = x4 / norm(x4);

fprintf('幂迭代行为分析:\n');
fprintf('迭代    Rayleigh商      向量范数    收敛性\n');
fprintf('----    ----------      --------    ------\n');

lambda_history = [];
for k = 1:20
    y = A4 * x4;
    lambda = x4' * y;
    x4 = y / norm(y);
    
    lambda_history = [lambda_history; lambda];
    
    % 分析收敛性
    if k > 5
        recent_std = std(lambda_history(end-4:end));
        converging = recent_std < 1e-6;
    else
        converging = false;
    end
    
    fprintf('%4d    %10.6f      %8.6f    %6s\n', ...
            k, lambda, norm(x4), mat2str(converging));
end

%% 测试5：加速技术
fprintf('\n测试5：加速技术\n');
fprintf('目标：测试Aitken加速等技术的效果\n\n');

A5 = [3, 1, 0; 1, 2, 1; 0, 1, 1];
exact_lambda = max(eig(A5));

% 标准幂迭代
x_std = [1; 1; 1];
x_std = x_std / norm(x_std);
lambda_sequence = [];

for k = 1:15
    y = A5 * x_std;
    lambda = x_std' * y;
    x_std = y / norm(y);
    lambda_sequence = [lambda_sequence; lambda];
end

% Aitken加速
fprintf('Aitken加速效果:\n');
fprintf('迭代    标准幂迭代    Aitken加速    加速效果\n');
fprintf('----    ----------    ----------    --------\n');

for k = 3:length(lambda_sequence)
    lambda_std = lambda_sequence(k);
    
    % Aitken公式: s_n = s_{n-2} - (s_{n-1} - s_{n-2})^2 / (s_n - 2*s_{n-1} + s_{n-2})
    if k >= 3
        s0 = lambda_sequence(k-2);
        s1 = lambda_sequence(k-1);
        s2 = lambda_sequence(k);
        
        denominator = s2 - 2*s1 + s0;
        if abs(denominator) > 1e-12
            lambda_aitken = s0 - (s1 - s0)^2 / denominator;
        else
            lambda_aitken = s2;
        end
        
        error_std = abs(lambda_std - exact_lambda);
        error_aitken = abs(lambda_aitken - exact_lambda);
        
        if error_std > 0
            acceleration_factor = error_std / error_aitken;
        else
            acceleration_factor = 1;
        end
        
        fprintf('%4d    %10.6f    %10.6f    %8.2f\n', ...
                k, lambda_std, lambda_aitken, acceleration_factor);
    end
end

%% 测试6：多重特征值
fprintf('\n测试6：多重特征值\n');
fprintf('目标：分析重特征值对幂迭代的影响\n\n');

% 构造有重特征值的矩阵
A6 = [3, 1, 0, 0; 0, 3, 0, 0; 0, 0, 2, 1; 0, 0, 0, 2];
fprintf('重特征值矩阵 A6:\n');
disp(A6);

eigenvals_mult = eig(A6);
fprintf('特征值: [%.1f, %.1f, %.1f, %.1f]\n', sort(eigenvals_mult, 'descend'));

% 分析重数
unique_vals = unique(round(eigenvals_mult, 10));
for val = unique_vals'
    multiplicity = sum(abs(eigenvals_mult - val) < 1e-10);
    fprintf('特征值 %.1f 的重数: %d\n', val, multiplicity);
end

% 幂迭代行为
x6 = [1; 1; 1; 1];
x6 = x6 / norm(x6);

fprintf('\n重特征值情况下的幂迭代:\n');
fprintf('迭代    Rayleigh商    收敛指标\n');
fprintf('----    ----------    --------\n');

lambda_old = 0;
for k = 1:25
    y = A6 * x6;
    lambda = x6' * y;
    x6 = y / norm(y);
    
    convergence_indicator = abs(lambda - lambda_old);
    
    if k <= 10 || mod(k, 5) == 0
        fprintf('%4d    %10.6f    %.2e\n', k, lambda, convergence_indicator);
    end
    
    lambda_old = lambda;
end

%% 测试7：大规模矩阵性能
fprintf('\n测试7：大规模矩阵性能\n');
fprintf('目标：测试幂迭代在大规模矩阵上的性能\n\n');

sizes = [100, 500, 1000, 2000];
fprintf('矩阵规模    计算时间    内存使用    迭代次数\n');
fprintf('--------    --------    --------    --------\n');

for n = sizes
    % 构造大规模稀疏矩阵
    A_large = spdiags([ones(n,1), 2*ones(n,1), ones(n,1)], [-1, 0, 1], n, n);
    A_large = A_large + 0.1 * speye(n);  % 确保主特征值唯一
    
    % 幂迭代
    x_large = randn(n, 1);
    x_large = x_large / norm(x_large);
    
    tic;
    memory_before = memory;
    
    for k = 1:100
        y = A_large * x_large;
        lambda = x_large' * y;
        x_large = y / norm(y);
        
        if k > 1 && abs(lambda - lambda_old) < 1e-8
            break;
        end
        lambda_old = lambda;
    end
    
    time_elapsed = toc;
    memory_after = memory;
    memory_used = memory_after.MemUsedMATLAB - memory_before.MemUsedMATLAB;
    
    fprintf('%6d      %8.4f    %8.2f    %8d\n', ...
            n, time_elapsed, memory_used/1e6, k);
end

fprintf('\n=== 幂迭代方法测试总结 ===\n');
fprintf('1. 特征值比值直接影响收敛速度\n');
fprintf('2. 初始向量的选择影响收敛行为\n');
fprintf('3. 高条件数矩阵可能导致数值不稳定\n');
fprintf('4. 复特征值情况下幂迭代可能不收敛\n');
fprintf('5. Aitken加速可以显著提高收敛速度\n');
fprintf('6. 重特征值会影响收敛行为\n');
fprintf('7. 幂迭代对大规模稀疏矩阵很有效\n\n');

end